import { getToken } from '@/utils/auth'

// 获取API基础URL，与request.js保持一致
const baseURL = process.env.VUE_APP_BASE_API || '/api'

/**
 * 执行 Workflow（流式）
 * @param {Object} params
 * @param {Object} params.inputs - 工作流输入变量（必填）
 * @param {string} params.user - 用户标识（必填）
 * @param {string} params.responseMode - 返回响应模式：streaming 或 blocking（默认：streaming）
 * @param {Array} params.files - 文件列表（可选）
 * @param {string} params.traceId - 链路追踪ID（可选）
 * @param {string} params.appName - App名称（可选）
 * @param {string} params.workflowId - 工作流ID（可选，用于执行指定版本）
 * @param {Function} onMessage - 消息回调
 * @param {Function} onEnd - 结束回调
 * @param {Function} onError - 错误回调
 * @returns {Object} 返回包含 abort 方法的对象，用于手动中断
 */
export function runWorkflow({ inputs, user, responseMode = 'streaming', files = [], traceId, appName, workflowId }, onMessage, onEnd, onError) {
  // 构建后端期望的请求体格式
  const requestData = {
    inputs: inputs || {},
    responseMode: responseMode,
    user: user
  }

  // 添加 App名称（如果提供）
  if (appName) {
    requestData.appName = appName
    console.log('🔑 Workflow - 使用 App名称:', appName)
  }

  // 添加 files（如果提供）
  if (files && files.length > 0) {
    requestData.files = files
    console.log('📎 Workflow - 添加 files:', files.length, '个文件')
  }

  // 添加 traceId（如果提供）
  if (traceId) {
    requestData.traceId = traceId
  }

  // 打印最终的请求体（调试用）
  console.log('🌐 Workflow - 发送到后端API的请求体:', JSON.stringify(requestData, null, 2))

  let isAborted = false
  const xhr = new XMLHttpRequest()
  
  // 构建请求URL（注意：后端 Controller 路径是 /api/ai/chat，所以 Workflow 路径是 /api/ai/chat/workflow/run）
  let requestUrl = `${baseURL}/api/ai/chat/workflow/run`
  if (workflowId) {
    requestUrl = `${baseURL}/api/ai/chat/workflow/${workflowId}/run`
  }
  
  xhr.open('POST', requestUrl, true)
  xhr.setRequestHeader('Content-Type', 'application/json')
  xhr.setRequestHeader('Accept', 'text/event-stream')
  
  // 添加token到请求头
  const token = getToken()
  if (token) {
    xhr.setRequestHeader('token', token)
    console.log('🔑 Workflow - 已添加token到请求头')
  }
  
  if ('withCredentials' in xhr) {
    xhr.withCredentials = false
  }

  // SSE数据解析
  let lastIndex = 0
  let buffer = ''
  let isEnded = false // 标记是否已经调用过 onEnd，避免重复调用
  
  // 安全的 onEnd 调用函数，确保只调用一次
  const safeOnEnd = (data) => {
    if (!isEnded) {
      isEnded = true
      console.log('调用 onEnd 回调，结束工作流')
      onEnd && onEnd(data || {})
    }
  }
  
  const processChunk = () => {
    const newData = xhr.responseText.substring(lastIndex)
    if (!newData) return
    lastIndex = xhr.responseText.length
    
    // 将新数据添加到缓冲区
    buffer += newData
    
    // 按行分割数据
    const lines = buffer.split('\n')
    
    // 保留最后一行（可能不完整）
    buffer = lines.pop() || ''

    // 处理完整的行
    for (let line of lines) {
      if (!line.trim()) continue
      line = line.trim()
      
      if (line.startsWith('data:')) {
        const payload = line.substring(5).trim()
        if (payload === '[DONE]') {
          console.log('Workflow SSE流完成 - 收到 [DONE] 标记')
          safeOnEnd({})
          return
        } else if (payload) {
          try {
            const parsed = JSON.parse(payload)
            
            // 处理错误
            if (parsed.error) {
              onError && onError({
                event: 'error',
                message: parsed.error
              })
              return
            }
            
            // 处理各种事件类型
            if (parsed.event) {
              onMessage && onMessage(parsed)
              // 当收到 workflow_finished 事件时，自动调用 onEnd 结束流
              if (parsed.event === 'workflow_finished') {
                console.log('收到 workflow_finished 事件，准备结束流')
                // 延迟一小段时间确保所有消息都已处理，然后调用 onEnd
                setTimeout(() => {
                  safeOnEnd(parsed.data || {})
                }, 100)
              }
            }
          } catch (e) {
            console.log('Workflow SSE JSON解析失败:', payload, '错误:', e.message)
          }
        }
      } else if (line.startsWith('{') && line.endsWith('}')) {
        // 处理没有"data: "前缀的JSON行
        try {
          const parsed = JSON.parse(line)
          
          if (parsed.error) {
            onError && onError({
              event: 'error',
              message: parsed.error
            })
            return
          }
          
          if (parsed.event) {
            onMessage && onMessage(parsed)
            // 当收到 workflow_finished 事件时，自动调用 onEnd 结束流
            if (parsed.event === 'workflow_finished') {
              console.log('收到 workflow_finished 事件，准备结束流')
              // 延迟一小段时间确保所有消息都已处理，然后调用 onEnd
              setTimeout(() => {
                safeOnEnd(parsed.data || {})
              }, 100)
            }
          }
        } catch (e) {
          console.log('Workflow SSE JSON解析失败:', line, '错误:', e.message)
        }
      }
    }
  }

  xhr.onprogress = processChunk
  xhr.onreadystatechange = function() {
    if (xhr.readyState === 4) {
      if (xhr.status === 200) {
        // 请求完成，如果没有收到 workflow_finished 或 [DONE]，则调用 onEnd
        setTimeout(() => {
          safeOnEnd({})
        }, 200)
      } else if (xhr.status !== 0) {
        // 请求失败
        onError && onError({
          event: 'error',
          message: `HTTP error! status: ${xhr.status}`
        })
      }
    }
  }
  
  xhr.onerror = function() {
    onError && onError({
      event: 'error',
      message: '网络错误'
    })
  }
  
  // 支持 AbortSignal
  // if (signal) {
  //   signal.addEventListener('abort', () => {
  //     isAborted = true
  //     xhr.abort()
  //   })
  // }
  
  xhr.send(JSON.stringify(requestData))

  return {
    abort: () => {
      isAborted = true
      xhr.abort()
    }
  }
}

/**
 * 获取 Workflow 执行情况
 * @param {string} workflowRunId - Workflow 执行ID
 * @param {string} appName - App名称（可选）
 */
export async function getWorkflowRun(workflowRunId, appName = null) {
  const params = {}
  if (appName) {
    params.appName = appName
  }
  
  const token = getToken()
  const headers = {
    'Content-Type': 'application/json'
  }
  if (token) {
    headers['token'] = token
  }
  
  const response = await fetch(`${baseURL}/api/ai/chat/workflow/run/${workflowRunId}${appName ? '?appName=' + encodeURIComponent(appName) : ''}`, {
    method: 'GET',
    headers: headers
  })
  
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }
  
  return await response.json()
}

/**
 * 停止 Workflow 任务
 * @param {string} taskId - 任务ID
 * @param {string} appName - App名称（可选）
 */
export async function stopWorkflowTask(taskId, appName = null) {
  const params = {}
  if (appName) {
    params.appName = appName
  }
  
  const token = getToken()
  const headers = {
    'Content-Type': 'application/json'
  }
  if (token) {
    headers['token'] = token
  }
  
  const response = await fetch(`${baseURL}/api/ai/chat/workflow/tasks/${taskId}/stop${appName ? '?appName=' + encodeURIComponent(appName) : ''}`, {
    method: 'POST',
    headers: headers
  })
  
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }
  
  return await response.json()
}

/**
 * 获取应用基本信息
 * @param {string} appName - App名称（可选）
 */
export async function getWorkflowInfo(appName = null) {
  const params = {}
  if (appName) {
    params.appName = appName
  }
  
  const token = getToken()
  const headers = {
    'Content-Type': 'application/json'
  }
  if (token) {
    headers['token'] = token
  }
  
  const response = await fetch(`${baseURL}/api/ai/chat/workflow/info${appName ? '?appName=' + encodeURIComponent(appName) : ''}`, {
    method: 'GET',
    headers: headers
  })
  
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }
  
  return await response.json()
}

/**
 * 获取应用参数
 * @param {string} appName - App名称（可选）
 */
export async function getWorkflowParameters(appName = null) {
  const token = getToken()
  const headers = {
    'Content-Type': 'application/json'
  }
  if (token) {
    headers['token'] = token
  }
  
  const response = await fetch(`${baseURL}/api/ai/chat/dify/parameters${appName ? '?appName=' + encodeURIComponent(appName) : ''}`, {
    method: 'GET',
    headers: headers
  })
  
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }
  
  return await response.json()
}

